﻿#include "PostCommandPy.h"
#include <QThread>
#include "BaseModule/IBaseSignal.h"
#include "CommandManager/CommandManager.h"
#include "CommandManager/CommandManagerPy.h"

#include "CmdLineChartWindowSetIsEdit.h"
#include "CmdLineChartChangeLineProperty.h"
#include "CmdCenterWidgetTabWidgetCurrentChanged.h"
#include "CmdLineChartCurve2DPlotorGuideLineSelectRemove.h"
#include "CmdLineChartCurve2DPlotorGuideLineAllRemove.h"
#include "CmdLineChartCurve2DPlotorMarkerSelectRemove.h"
#include "CmdLineChartCurve2DPlotorMarkerAllRemove.h"
#include "CmdLineChartLineChartTracerSelectChange.h"
#include "CmdLineChartLineChartStraightLineSelectChange.h"
#include "CmdLineChartWindowChangeGuideLineProperty.h"
#include "CmdLineChartWindowChangeTracerProperty.h"
#include "CmdLineChartAxisLineUpdate.h"
#include "CmdLineChartComputeHIRF.h"
#include "CmdLineChartSidebarSettingsRemoveSelectedGraph.h"
#include "CmdLineChartSidebarSettingsDeleteAllCurve.h"
#include "CmdLineChartCreateLineChartStraightLine.h"
#include "CmdLineChartMeasureButtonClicked.h"
#include "CmdLineChartSidebarSettingsRenameCheck.h"
#include "CmdLineChartCenterWidgetMoveLegend.h"
#include "CmdLineChartCenterWidgetDialogAddLocalRange.h"
#include "CmdLineChartCurve2DPlotorRemoveSelectedGraph.h"
#include "CmdLineChartCurve2DPlotorRemoveAllGraphs.h"
#include "CmdLineChartDialogCurveSmoothing.h"
#include "CmdLineChartDialogWaveformAnalysis.h"
#include "CmdLineChartDialogIPLCalculation.h";
#include "CmdLineChartDialogTransferFunction.h"
#include "CmdLineChartCenterWidgetInfoListPaste.h";
#include "CmdLineChartSidebarSettingsAllVariableAxisSet.h";
#include "CmdLineChartSidebarSettingsComplex.h";
#include "CmdLineChartSidebarSettingsFormulaEditor.h";
#include "CmdLineChartSidebarSettingsCopySelectedGraph.h"
#include "CmdLineChartComputeEffectiveness.h"
#include "CmdLineChartDialogInterpolation.h"
#include "CmdProjectTreeSelectionChanged.h"
#include "CmdSaveGraph.h"
#include "CmdDataImport.h"
#include "CmdCreateTwoDLineChart.h"
#include "CmdOpenProject.h"
#include "CmdImportProjectData.h"
#include "CmdCreateThreeDSurfacePlot.h"
#include "CmdCreateThreeDCloudMap.h"
#include "CmdCreateSurfaceElectricFieldGraph.h"
#include "CmdSetHeatMapSelectedCurveNameIndexs.h"
#include "CmdSetHeatMapVariableAxisChanged.h"
#include "CmdSetHeatMapSecondVariableAxisChanged.h"
#include "CmdSetHeatMapDataOprationChange.h"
#include "CmdSetHeatMapCurveNameCheckStateChanged.h"
#include "CmdSetHeatMapResultValueDataChanged.h"
#include "CmdSetHeatMapRemoveSelectedGraph.h"
#include "CmdSaveHeatMapMainSettingData.h"
#include "CmdSetHeatMapFixedValueChanged.h"
#include "CmdSetHeatMapComplexPartsChanged.h"
#include "CmdSetHeatMapRenameFinished.h"
#include "CmdSetHeatMapAddTracer.h"
#include "CmdSetHeatMapRemoveSelectedTracer.h"
#include "CmdSetHeatMapRemoveAllTracer.h"
#include "CmdSetHeatMapExportMarkerData.h"
#include "CmdSetHeatMapChangeTracerProperty.h"
#include "CmdCreateTableWidget.h"
#include "CmdThreeDSurfacePlotSidebarResultDataChanged.h"
#include "CmdThreeDSurfacePlotSidebarFrequencyChanged.h"
#include "CmdThreeDSurfacePlotSidebarDataOprationChanged.h"
#include "CmdThreeDSurfacePlotSidebarCurveNameItemCheckStateChanged.h"
#include "CmdThreeDSurfacePlotSidebarCurveNameClicked.h"
#include "CmdThreeDSurfaceCurveDataFileterRadioButtonClicked.h"
#include "CmdSaveThreeDSurfacePlotMainSettingData.h"
#include "CmdSaveThreeDSurfacePlotMoveResultDataSetting.h"
#include "CmdThreeDCloudMapSidebarCurveNameClicked.h"
#include "CmdThreeDCloudMapSidebarUpdateFixedParameter.h"
#include "CmdThreeDCloudMapSidebarUpdateOriginalDataSource.h"
#include "CmdThreeDCloudMapSidebarResultDataChanged.h"
#include "CmdThreeDCloudMapSidebarNameItemRename.h"
#include "CmdThreeDCloudMapSidebarDelete3DCloudMap.h"
#include "CmdThreeDCloudMapSidebarDataOprationChanged.h"
#include "CmdThreeDCloudMapSidebarItemCheckStateChanged.h"
#include "CmdSaveThreeDCloudMapMainSettingData.h"
#include "CmdSurfaceElectricFieldMapSidebarItemCheckStateChanged.h"
#include "CmdSaveSurfaceElectricFieldMapMainSettingData.h"
#include "CmdSaveSurfaceElectricFieldMapMainSettingData.h"
#include "CmdSurfaceElectricFieldMapSidebarResultDataChanged.h"
#include "CmdSurfaceElectricFieldMapSidebarUpdateProcessData.h"
#include "CmdSurfaceElectricFieldMapSidebarNameItemRename.h"
#include "CmdSurfaceElectricFieldMapSidebarDeleteSurfaceElectricFieldMap.h"
#include "CmdSurfaceElectricFieldMapSidebarCurveNameClicked.h"
#include "CmdSavePostMarkerAddSettingData.h"
#include "CmdSavePostMarkerRemoveChosenSettingData.h"
#include "CmdSavePostMarkerRemoveAllSettingData.h"
#include "CmdSavePostMarkerExportTableData.h"
#include "CmdSaveModelDisplaySettingData.h"
#include "CmdSaveActiveClipperSettingData.h"
#include "CmdPolarCoordinateGraphSidebarVariableAxisChanged.h"
#include "CmdPolarCoordinateGraphSidebarAllVariableAxisChanged.h"
#include "CmdPolarCoordinateGraphSidebarCurveNameClicked.h"
#include "CmdPolarCoordinateGraphSidebarCurveNameCheckStateChanged.h"
#include "CmdPolarCoordinateGraphSidebarDataOperationChanged.h"
#include "CmdPolarCoordinateGraphSidebarValueDataChanged.h"
#include "CmdPolarCoordinateGraphSidebarRenameSelectedGraph.h"
#include "CmdPolarCoordinateGraphSidebarCopySelectedGraph.h"
#include "CmdPolarCoordinateGraphSidebarComplexPartsChanged.h"
#include "CmdPolarCoordinateGraphSidebarRemoveSelectedGraph.h"
#include "CmdPolarCoordinateGraphSidebarDeleteAllGraph.h"
#include "CmdPolarCoordinateGraphSidebarFixedValueChanged.h"
#include "CmdPolarCoordinateGraphAddTracer.h"
#include "CmdPolarCoordinateGraphRemoveSelectedTracer.h"
#include "CmdPolarCoordinateGraphRemoveAllTracer.h"
#include "CmdPolarCoordinateGraphExportMarkerData.h"
#include "CmdPolarCoordinateGraphChangeTracerProperty.h"
#include "CmdSavePolarCoordinateGraphMainSettingData.h"
#include "CmdLineChartSidebarVariableAxisChanged.h"
#include "CmdLineChartSidebarCurveNameClicked.h"
#include "CmdLineChartSidebarCurveNameCheckStateChanged.h"
#include "CmdLineChartSidebarDataOperationChanged.h"
#include "CmdLineChartSidebarValueDataChanged.h"
#include "CmdSaveLineChartMainSettingData.h"
#include "CmdLineChartSidebarFixedValueChanged.h"
#include "CmdExportPstData.h"
#include "CmdDelete3DSurfacePlots.h"
#include "CmdThreeDSurfaceCurveNameItemRename.h"
#include "CmdWaveButterANdFFT.h"
#include "CmdTbHideOrShowTableColumn.h"
#include "CmdTbChangeColumnName.h"
#include "CmdTbFlushTbBySelectedRow.h"
#include "CmdTbExportData.h"
#include "CmdTbhighlightSelectedColumns.h"
#include "CmdAppPrjFileWrite.h"
#include "CmdAppPrjFileRead.h"
#include "CmdDoPrjCloseTree.h"
#include "CmdDoPrjTreeCopyDir.h"
#include "CmdDoPrjTreePasteDir.h"
#include "CmdDoPrjTreeCopyData.h"
#include "CmdDoPrjTreePasteData.h"
#include "CmdDoPrjTreeExpandDir.h"
#include "CmdDoPrjTreeCollapseDir.h"
#include "CmdSubmitEvaluation.h"
#include "CmdCloseCenterTableBar.h"
#include "CmdChangeCurrentTabBar.h"
#include "CmdLineChartWindowAddTracer.h"
#include <iostream>
#include <QDebug>
namespace PostCommand
{
    PostCommandPy* PostCommandPy::m_instance = nullptr;

    PostCommandPy* PostCommandPy::getInstance()
    {
        if (m_instance == nullptr)
        {
            m_instance = new PostCommandPy;
        }
        return m_instance;
    }

    PostCommandPy::PostCommandPy()
    {
        CommandManagerInstance;
        initConnect();
    }

    void PostCommandPy::initConnect()
    {
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_smartScriptSave, this, &PostCommandPy::slot_smartScriptSave);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_smartScriptRun, this, &PostCommandPy::slot_smartScriptRun, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_smartScriptEdit, this, &PostCommandPy::slot_smartScriptEdit, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_projectTreeSelectionChanged, this, &PostCommandPy::slot_projectTreeSelectionChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_saveGraph, this, &PostCommandPy::slot_saveGraph);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_dataImport, this, &PostCommandPy::slot_dataImport);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_createTwoDLineChart, this, &PostCommandPy::slot_createTwoDLineChart, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_setHeatMapSelectedCurveNameIndexs, this, &PostCommandPy::slot_setHeatMapSelectedCurveNameIndexs);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_setHeatMapVariableAxisChanged, this, &PostCommandPy::slot_setHeatMapVariableAxisChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_setHeatMapSecondVariableAxisChanged, this, &PostCommandPy::slot_setHeatMapSecondVariableAxisChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_setHeatMapCurveNameCheckStateChanged, this, &PostCommandPy::slot_setHeatMapCurveNameCheckStateChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_setHeatMapDataOprationChanged, this, &PostCommandPy::slot_setHeatMapDataOprationChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_setHeatMapResultValueDataChanged, this, &PostCommandPy::slot_setHeatMapResultValueDataChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_saveHeatMapMainSettingData, this, &PostCommandPy::slot_saveHeatMapMainSettingData);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_setHeatMapFixedValueChanged, this, &PostCommandPy::slot_setHeatMapFixedValueChanged, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_setHeatMapComplexPartsChanged, this, &PostCommandPy::slot_setHeatMapComplexPartsChanged, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_setHeatMapRemoveSelectedGraph, this, &PostCommandPy::slot_setHeatMapRemoveSelectedGraph, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_setHeatMapRenameFinished, this, &PostCommandPy::slot_setHeatMapRenameFinished, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_setHeatMapAddTracer, this, &PostCommandPy::slot_setHeatMapAddTracer, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_setHeatMapRemoveSelectedTracer, this, &PostCommandPy::slot_setHeatMapRemoveSelectedTracer, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_setHeatMapRemoveAllTracer, this, &PostCommandPy::slot_setHeatMapRemoveAllTracer, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_setHeatMapExportMarkerData, this, &PostCommandPy::slot_setHeatMapExportMarkerData, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_setHeatMapChangeTracerProperty, this, &PostCommandPy::slot_setHeatMapChangeTracerProperty, Qt::ConnectionType::DirectConnection);

        // 二维折线图
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartSidebarVariableAxisChanged, this, &PostCommandPy::slot_lineChartSidebarVariableAxisChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartSidebarCurveNameClicked, this, &PostCommandPy::slot_lineChartSidebarCurveNameClicked, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartSidebarCurveNameCheckStateChanged, this, &PostCommandPy::slot_lineChartSidebarCurveNameCheckStateChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartSidebarDataOperationChanged, this, &PostCommandPy::slot_lineChartSidebarDataOperationChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartSidebarFixedValueChanged, this, &PostCommandPy::slot_lineChartSidebarFixedValueChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartSidebarValueDataChanged, this, &PostCommandPy::slot_lineChartSidebarValueDataChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_saveLineChartMainSettingData, this, &PostCommandPy::slot_saveLineChartMainSettingData);

        // 极坐标图
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_polarCoordinateGraphSidebarVariableAxisChanged, this, &PostCommandPy::slot_polarCoordinateGraphSidebarVariableAxisChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_polarCoordinateGraphSidebarAllVariableAxisChanged, this, &PostCommandPy::slot_polarCoordinateGraphSidebarAllVariableAxisChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_polarCoordinateGraphSidebarCurveNameClicked, this, &PostCommandPy::slot_polarCoordinateGraphSidebarCurveNameClicked);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_polarCoordinateGraphSidebarCurveNameCheckStateChanged, this, &PostCommandPy::slot_polarCoordinateGraphSidebarCurveNameCheckStateChanged, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_polarCoordinateGraphSidebarDataOperationChanged, this, &PostCommandPy::slot_polarCoordinateGraphSidebarDataOperationChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_polarCoordinateGraphSidebarValueDataChanged, this, &PostCommandPy::slot_polarCoordinateGraphSidebarValueDataChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_savePolarCoordinateGraphMainSettingData, this, &PostCommandPy::slot_savePolarCoordinateGraphMainSettingData, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_polarCoordinateGraphSidebarDeleteAllGraph, this, &PostCommandPy::slot_polarCoordinateGraphSidebarDeleteAllGraph, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_polarCoordinateGraphSidebarRenameSelectedGraph, this, &PostCommandPy::slot_polarCoordinateGraphSidebarRenameSelectedGraph, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_polarCoordinateGraphSidebarComplexPartsChanged, this, &PostCommandPy::slot_polarCoordinateGraphSidebarComplexPartsChanged, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_polarCoordinateGraphSidebarFixedValueChanged, this, &PostCommandPy::slot_polarCoordinateGraphSidebarFixedValueChanged, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_polarCoordinateGraphSidebarRemoveSelectedGraph, this, &PostCommandPy::slot_polarCoordinateGraphSidebarRemoveSelectedGraph, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_polarCoordinateGraphSidebarCopySelectedGraph, this, &PostCommandPy::slot_polarCoordinateGraphSidebarCopySelectedGraph, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_polarCoordinateGraphAddTracer, this, &PostCommandPy::slot_polarCoordinateGraphAddTracer, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_polarCoordinateGraphRemoveSelectedTracer, this, &PostCommandPy::slot_polarCoordinateGraphRemoveSelectedTracer, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_polarCoordinateGraphRemoveAllTracer, this, &PostCommandPy::slot_polarCoordinateGraphRemoveAllTracer, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_polarCoordinateGraphExportMarkerData, this, &PostCommandPy::slot_polarCoordinateGraphExportMarkerData, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_polarCoordinateGraphChangeTracerProperty, this, &PostCommandPy::slot_polarCoordinateGraphChangeTracerProperty, Qt::ConnectionType::DirectConnection);

        // 三维曲面图
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_createThreeDSurfacePlot, this, &PostCommandPy::slot_createThreeDSurfacePlot);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_threeDSurfacePlotSidebarCurveNameClicked, this, &PostCommandPy::slot_threeDSurfacePlotSidebarCurveNameClicked);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_threeDSurfacePlotSidebarFrequencyChanged, this, &PostCommandPy::slot_threeDSurfacePlotSidebarFrequencyChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_threeDSurfacePlotSidebarResultDataChanged, this, &PostCommandPy::slot_threeDSurfacePlotSidebarResultDataChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_threeDSurfacePlotSidebarDataOprationChanged, this, &PostCommandPy::slot_threeDSurfacePlotSidebarDataOprationChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_threeDSurfacePlotSidebarCurveNameItemCheckStateChanged, this, &PostCommandPy::slot_threeDSurfacePlotSidebarCurveNameItemCheckStateChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_saveThreeDSurfacePlotMainSettingData, this, &PostCommandPy::slot_saveThreeDSurfacePlotMainSettingData);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_saveThreeDSurfacePlotMoveResultDataSetting, this, &PostCommandPy::slot_saveThreeDSurfacePlotMoveResultDataSetting);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_delete3DSurfacePlots, this, &PostCommandPy::slot_delete3DSurfacePlots);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_threeDSurfaceCurveNameItemRename, this, &PostCommandPy::slot_threeDSurfaceCurveNameItemRename);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_threeDSurfaceCurveDataFileterRadioButtonClicked, this, &PostCommandPy::slot_threeDSurfaceCurveDataFileterRadioButtonClicked);


        // 三维云图
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_createThreeDCloudMap, this, &PostCommandPy::slot_createThreeDCloudMap);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_threeDCloudMapSidebarCurveNameClicked, this, &PostCommandPy::slot_threeDCloudMapSidebarCurveNameClicked);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_threeDCloudMapSidebarItemCheckStateChanged, this, &PostCommandPy::slot_threeDCloudMapSidebarItemCheckStateChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_threeDCloudMapSidebarDataOprationChanged, this, &PostCommandPy::slot_threeDCloudMapSidebarDataOprationChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_threeDCloudMapSidebarUpdateFixedParameter, this, &PostCommandPy::slot_threeDCloudMapSidebarUpdateFixedParameter);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_threeDCloudMapSidebarUpdateOriginalDataSource, this, &PostCommandPy::slot_threeDCloudMapSidebarUpdateOriginalDataSource);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_threeDCloudMapSidebarResultDataChanged, this, &PostCommandPy::slot_threeDCloudMapSidebarResultDataChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_threeDCloudMapSidebarNameItemRename, this, &PostCommandPy::slot_threeDCloudMapSidebarNameItemRename);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_threeDCloudMapSidebarDelete3DCloudMap, this, &PostCommandPy::slot_threeDCloudMapSidebarDelete3DCloudMap);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_saveThreeDCloudMapMainSettingData, this, &PostCommandPy::slot_saveThreeDCloudMapMainSettingData);

        // 表面分布图
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_createSurfaceElectricFieldGraph, this, &PostCommandPy::slot_createSurfaceElectricFieldGraph);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_surfaceElectricFieldMapSidebarCurveNameClicked, this, &PostCommandPy::slot_surfaceElectricFieldMapSidebarCurveNameClicked);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_surfaceElectricFieldMapSidebarItemCheckStateChanged, this, &PostCommandPy::slot_surfaceElectricFieldMapSidebarItemCheckStateChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_surfaceElectricFieldMapSidebarResultDataChanged, this, &PostCommandPy::slot_surfaceElectricFieldMapSidebarResultDataChanged);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_surfaceElectricFieldMapSidebarUpdateProcessData, this, &PostCommandPy::slot_surfaceElectricFieldMapSidebarUpdateProcessData);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_surfaceElectricFieldMapSidebarNameItemRename, this, &PostCommandPy::slot_surfaceElectricFieldMapSidebarNameItemRename);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_surfaceElectricFieldMapSidebarDeleteSurfaceElectricFieldMap, this, &PostCommandPy::slot_surfaceElectricFieldMapSidebarDeleteSurfaceElectricFieldMap);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_saveSurfaceElectricFieldMapMainSettingData, this, &PostCommandPy::slot_saveSurfaceElectricFieldMapMainSettingData);

        //三维图标记
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_savePostMarkerAddSettingData, this, &PostCommandPy::slot_savePostMarkerAddSettingData);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_savePostMarkerRemoveChosenSettingData, this, &PostCommandPy::slot_savePostMarkerRemoveChosenSettingData);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_savePostMarkerRemoveAllSettingData, this, &PostCommandPy::slot_savePostMarkerRemoveAllSettingData);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_savePostMarkerExportTableData, this, &PostCommandPy::slot_savePostMarkerExportTableData);

        //模型显示
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_saveModelDisplaySettingData, this, &PostCommandPy::slot_saveModelDisplaySettingData);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_saveActiveClipperSettingData, this, &PostCommandPy::slot_saveActiveClipperSettingData);

        // 表格数据
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_createTableWidget, this, &PostCommandPy::slot_createTableWidget, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_hideOrShowTableColumn, this, &PostCommandPy::slot_hideOrShowTableColumn, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_changeTbColumnName, this, &PostCommandPy::slot_changeTbColumnName, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_flushTbBySelectedRow, this, &PostCommandPy::slot_flushTbBySelectedRow, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_exportTbData, this, &PostCommandPy::slot_exportTbData, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_highlightSelectedTbColumns, this, &PostCommandPy::slot_highlightSelectedTbColumns, Qt::ConnectionType::DirectConnection);
        // 工程数据
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_doPrjFileWrite, this, &PostCommandPy::slot_doPrjFileWrite, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_doPrjFileRead, this, &PostCommandPy::slot_doPrjFileRead, Qt::ConnectionType::BlockingQueuedConnection);

        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_doPrjCloseTree, this, &PostCommandPy::slot_doPrjCloseTree, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_doPrjTreeCopyDir, this, &PostCommandPy::slot_doPrjTreeCopyDir, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_doPrjTreePasteDir, this, &PostCommandPy::slot_doPrjTreePasteDir, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_doPrjTreeCopyData, this, &PostCommandPy::slot_doPrjTreeCopyData, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_doPrjTreePasteData, this, &PostCommandPy::slot_doPrjTreePasteData, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_doPrjTreeExpandDir, this, &PostCommandPy::slot_doPrjTreeExpandDir, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_doPrjTreeCollapseDir, this, &PostCommandPy::slot_doPrjTreeCollapseDir, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_closeCenterTableBar, this, &PostCommandPy::slot_closeCenterTableBar, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_changeCurrentTabBar, this, &PostCommandPy::slot_changeCurrentTabBar, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_submitEvaluation, this, &PostCommandPy::slot_submitEvaluation, Qt::ConnectionType::DirectConnection);

        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_openProject, this, &PostCommandPy::slot_openProject);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_exportPstData, this, &PostCommandPy::slot_exportPstData);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_importProjectData, this, &PostCommandPy::slot_importProjectData, Qt::BlockingQueuedConnection);

        
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartWindowSetIsEdit, this, &PostCommandPy::slot_lineChartWindowSetIsEdit, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartChangeLineProperty, this, &PostCommandPy::slot_lineChartChangeLineProperty, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_centerWidgetTabWidgetCurrentChanged, this, &PostCommandPy::slot_centerWidgetTabWidgetCurrentChanged, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartCurve2DPlotorGuideLineSelectRemove, this, &PostCommandPy::slot_lineChartCurve2DPlotorGuideLineSelectRemove, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartCurve2DPlotorGuideLineAllRemove, this, &PostCommandPy::slot_lineChartCurve2DPlotorGuideLineAllRemove, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartCurve2DPlotorMarkerSelectRemove, this, &PostCommandPy::slot_lineChartCurve2DPlotorMarkerSelectRemove, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartCurve2DPlotorMarkerAllRemove, this, &PostCommandPy::slot_lineChartCurve2DPlotorMarkerAllRemove, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartLineChartTracerSelectChange, this, &PostCommandPy::slot_lineChartLineChartTracerSelectChange, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartLineChartStraightLineSelectChange, this, &PostCommandPy::slot_lineChartLineChartStraightLineSelectChange, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartWindowChangeGuideLineProperty, this, &PostCommandPy::slot_lineChartWindowChangeGuideLineProperty, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartWindowChangeTracerProperty, this, &PostCommandPy::slot_lineChartWindowChangeTracerProperty, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartAxisLineUpdate, this, &PostCommandPy::slot_lineChartAxisLineUpdate, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartComputeHIRF, this, &PostCommandPy::slot_lineChartComputeHIRF, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartSidebarSettingsRemoveSelectedGraph, this, &PostCommandPy::slot_lineChartSidebarSettingsRemoveSelectedGraph, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartSidebarSettingsDeleteAllCurve, this, &PostCommandPy::slot_lineChartSidebarSettingsDeleteAllCurve, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartCreateLineChartStraightLine, this, &PostCommandPy::slot_lineChartCreateLineChartStraightLine, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartMeasureButtonClicked, this, &PostCommandPy::slot_lineChartMeasureButtonClicked, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartSidebarSettingsRenameCheck, this, &PostCommandPy::slot_lineChartSidebarSettingsRenameCheck, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartCenterWidgetMoveLegend, this, &PostCommandPy::slot_lineChartCenterWidgetMoveLegend, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartWindowAddTracer, this, &PostCommandPy::slot_lineChartWindowAddTracer, Qt::ConnectionType::DirectConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartCenterWidgetDialogAddLocalRange, this, &PostCommandPy::slot_lineChartCenterWidgetDialogAddLocalRange, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartCurve2DPlotorRemoveSelectedGraph, this, &PostCommandPy::slot_lineChartCurve2DPlotorRemoveSelectedGraph, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartCurve2DPlotorRemoveAllGraphs, this, &PostCommandPy::slot_lineChartCurve2DPlotorRemoveAllGraphs, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartDialogCurveSmoothing, this, &PostCommandPy::slot_lineChartDialogCurveSmoothing, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartDialogWaveformAnalysis, this, &PostCommandPy::slot_lineChartDialogWaveformAnalysis, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartDialogIPLCalculation, this, &PostCommandPy::slot_lineChartDialogIPLCalculation, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartDialogTransferFunction, this, &PostCommandPy::slot_lineChartDialogTransferFunction, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartCenterWidgetInfoListPaste, this, &PostCommandPy::slot_lineChartCenterWidgetInfoListPaste, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartSidebarSettingsAllVariableAxisSet, this, &PostCommandPy::slot_lineChartSidebarSettingsAllVariableAxisSet, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartSidebarSettingsComplex, this, &PostCommandPy::slot_lineChartSidebarSettingsComplex, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartSidebarSettingsFormulaEditor, this, &PostCommandPy::slot_lineChartSidebarSettingsFormulaEditor, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartSidebarSettingsCopySelectedGraph, this, &PostCommandPy::slot_lineChartSidebarSettingsCopySelectedGraph, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartComputeEffectiveness, this, &PostCommandPy::slot_lineChartComputeEffectiveness, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_lineChartDialogInterpolation, this, &PostCommandPy::slot_lineChartDialogInterpolation, Qt::BlockingQueuedConnection);
        connect(CommandManagerPyInstance, &CommandManager::CommandManagerPy::signal_sentWaveButterANdFFTVResult, this, &PostCommandPy::slot_sentWaveButterANdFFTVResult);


    }


    void PostCommandPy::slot_lineChartWindowSetIsEdit(bool state)
    {
        auto _command = new CmdLineChartWindowSetIsEdit();
        _command->setData(state);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }
    void PostCommandPy::slot_lineChartChangeLineProperty(int windowUniversalID, int curveInfoID, QString docStr)
    {
        auto _command = new CmdLineChartChangeLineProperty();
        _command->setData(windowUniversalID, curveInfoID, docStr);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_centerWidgetTabWidgetCurrentChanged(int currentIndex)
    {
        auto _command = new CmdCenterWidgetTabWidgetCurrentChanged();
        _command->setData(currentIndex);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_lineChartCurve2DPlotorGuideLineSelectRemove()
    {
        auto _command = new CmdLineChartCurve2DPlotorGuideLineSelectRemove();
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }
    void PostCommandPy::slot_lineChartCurve2DPlotorGuideLineAllRemove()
    {
        auto _command = new CmdLineChartCurve2DPlotorGuideLineAllRemove();
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }
    void PostCommandPy::slot_lineChartCurve2DPlotorMarkerSelectRemove()
    {
        auto _command = new CmdLineChartCurve2DPlotorMarkerSelectRemove();
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }
    void PostCommandPy::slot_lineChartCurve2DPlotorMarkerAllRemove()
    {
        auto _command = new CmdLineChartCurve2DPlotorMarkerAllRemove();
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }


    void PostCommandPy::slot_lineChartLineChartTracerSelectChange(int id, bool selected)
    {
        auto _command = new CmdLineChartLineChartTracerSelectChange();
        _command->setData(id, selected);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_lineChartLineChartStraightLineSelectChange(int id, bool selected)
    {
        auto _command = new CmdLineChartLineChartStraightLineSelectChange();
        _command->setData(id, selected);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_lineChartWindowChangeGuideLineProperty(int guideLineID, double value, int guideLineStyle, double guideLineThickness, QString guideLineColor)
    {
        auto _command = new CmdLineChartWindowChangeGuideLineProperty();
        _command->setData(guideLineID, value, guideLineStyle, guideLineThickness, guideLineColor);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_lineChartWindowChangeTracerProperty(int tracerID, QString tracerName, double x, int symbolStyle, double symbolSize, QString symbolColor)
    {
        auto _command = new CmdLineChartWindowChangeTracerProperty();
        _command->setData(tracerID, tracerName, x, symbolStyle, symbolSize, symbolColor);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_lineChartAxisLineUpdate(QString typeAxis, int id, double value)
    {
        auto _command = new CmdLineChartAxisLineUpdate();
        _command->setData(typeAxis, id, value);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }
    void PostCommandPy::slot_lineChartComputeHIRF(const QString& graphNames, double incidentWaveFieldValue, const QString& HIRFName, const QString& typeName, bool isCheckBoxChecked)
    {
        auto _command = new CmdLineChartComputeHIRF();
        _command->setData(graphNames, incidentWaveFieldValue, HIRFName, typeName, isCheckBoxChecked);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_lineChartSidebarSettingsDeleteAllCurve()
    {
        auto _command = new CmdLineChartSidebarSettingsDeleteAllCurve();
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_lineChartSidebarSettingsRemoveSelectedGraph()
    {
        auto _command = new CmdLineChartSidebarSettingsRemoveSelectedGraph();
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_lineChartCreateLineChartStraightLine(int typeAxis) {
        auto _command = new CmdLineChartCreateLineChartStraightLine();
        _command->setData(typeAxis);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }
    void PostCommandPy::slot_lineChartMeasureButtonClicked(int meaureTypeInt, double value) {
        auto _command = new CmdLineChartMeasureButtonClicked();
        _command->setData(meaureTypeInt, value);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }
    
    void PostCommandPy::slot_lineChartSidebarSettingsRenameCheck(QString text)
    {
        auto _command = new CmdLineChartSidebarSettingsRenameCheck();
        _command->setData(text);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_lineChartCenterWidgetMoveLegend(int dataInt)
    {
        auto _command = new CmdLineChartCenterWidgetMoveLegend();
        _command->setData(dataInt);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }
    void PostCommandPy::slot_lineChartWindowAddTracer(int windowUniversalID, QString parameters)
    {
        auto _command = new CmdLineChartWindowAddTracer();
        _command->setData(windowUniversalID, parameters);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }
    void PostCommandPy::slot_lineChartCenterWidgetDialogAddLocalRange(double rangeLower, double rangeUpper, QString selectNames, bool execFlag, bool edit)
    {
        auto _command = new CmdLineChartCenterWidgetDialogAddLocalRange();
        _command->setData(rangeLower, rangeUpper, selectNames, execFlag, edit);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }
    void PostCommandPy::slot_lineChartCurve2DPlotorRemoveSelectedGraph()
    {
        auto _command = new CmdLineChartCurve2DPlotorRemoveSelectedGraph();
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }
    void PostCommandPy::slot_lineChartCurve2DPlotorRemoveAllGraphs()
    {
        auto _command = new CmdLineChartCurve2DPlotorRemoveAllGraphs();
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }
    void PostCommandPy::slot_lineChartDialogCurveSmoothing(double range)
    {
        auto _command = new CmdLineChartDialogCurveSmoothing();
        _command->setData(range);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_lineChartDialogWaveformAnalysis(QString graphName, double cutOffFrequency, QString filterType, int filterOrder, double leftBoundary, double rightBoundary, int windowId, QString resultList)
    {
        auto _command = new CmdLineChartDialogWaveformAnalysis();
        _command->setData(graphName, cutOffFrequency, filterType, filterOrder, leftBoundary, rightBoundary,windowId, resultList);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_lineChartDialogIPLCalculation(QString IPLString)
    {
        auto _command = new CmdLineChartDialogIPLCalculation();
        _command->setData(IPLString);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }
    void PostCommandPy::slot_lineChartDialogTransferFunction(QString graphName, QString calibrationGraphName, QString type)
    {
        auto _command = new CmdLineChartDialogTransferFunction();
        _command->setData(graphName, calibrationGraphName, type);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }
    void PostCommandPy::slot_lineChartCenterWidgetInfoListPaste(QString infoIds)
    {
        auto _command = new CmdLineChartCenterWidgetInfoListPaste();
        _command->setData(infoIds);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_lineChartDialogInterpolation(int number, int type)
    {
        auto _command = new CmdLineChartDialogInterpolation();
        _command->setData(number, type);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }


    void PostCommandPy::slot_lineChartComputeEffectiveness(QString graphNames, double e0)
    {
        auto _command = new CmdLineChartComputeEffectiveness();
        _command->setData(graphNames, e0);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_lineChartSidebarSettingsCopySelectedGraph()
    {
        auto _command = new CmdLineChartSidebarSettingsCopySelectedGraph();
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }
    
    void PostCommandPy::slot_lineChartSidebarSettingsFormulaEditor(QString data)
    {
        auto _command = new CmdLineChartSidebarSettingsFormulaEditor();
        _command->setData(data);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    
    void PostCommandPy::slot_lineChartSidebarSettingsComplex(QString data)
    {
        auto _command = new CmdLineChartSidebarSettingsComplex();
        _command->setData(data);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_lineChartSidebarSettingsAllVariableAxisSet(QString data)
    {
        auto _command = new CmdLineChartSidebarSettingsAllVariableAxisSet();
        _command->setData(data);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::putErrorMsg(QString content)
    {
        emit IBaseSignalInstance->signal_showMessageToConsole(BaseModule::EMessageConsole::Error, content);
    }

    void PostCommandPy::slot_smartScriptSave(QString fileName)
    {
        emit IBaseSignalInstance->signal_saveScript(fileName);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_smartScriptRun(QString fileName, bool isNoGui, QString listPara)
    {
        QStringList _list;
        auto _stringList = QString(listPara).split('|');
        _stringList.removeAll("");
        for (QString item : _stringList)
        {
            _list.push_back(item);
        }

        emit IBaseSignalInstance->signal_execSmartScriptCode(fileName, _list);
    }

    void PostCommandPy::slot_smartScriptEdit(QString fileName, QString text)
    {
        emit IBaseSignalInstance->signal_editScript(fileName, text);
    }

    void PostCommandPy::slot_projectTreeSelectionChanged(QString projectTreeSelctedRowIDListStr)
    {
        auto _command = new CmdProjectTreeSelectionChanged();
        auto _rowStrList = projectTreeSelctedRowIDListStr.split(",");
        QList<int> _rowList;
        for (auto _rowStr : _rowStrList)
        {
            _rowList.push_back(_rowStr.toInt());
        }
        _command->setprojectTreeSelctedRowIDList(_rowList);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdProjectTreeSelectionChanged failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_saveGraph(QString filePath)
    {

        auto _command = new CmdSaveGraph();
        _command->setFilePath(filePath);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("saveGraph failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_dataImport(QString filePath, bool isTextOrCsv, QString customData)
    {
        auto _command = new CmdDataImport();
        _command->setFilePath(filePath);
        _command->setIsTextOrCsv(isTextOrCsv);
        _command->setCustomData(customData);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
        {
            putErrorMsg(QObject::tr("dataImport failed."));
            emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Stop);
        }

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_createTwoDLineChart(int lineChartType, int variableIndex, QList<QPair<int, QList<int>>> chosenkeyList, QList<int> valueIndexs, QList<int> selectParserIndex, bool isOpenNewWindow)
    {
        auto _command = new CmdCreateTwoDLineChart();
        _command->setLineChartType(lineChartType);
        _command->setVariableIndex(variableIndex);
        _command->setChosenkeyList(chosenkeyList);
        _command->setValueIndexs(valueIndexs);
        _command->setSelectParserIndex(selectParserIndex);
        _command->setIsOpenNewWindow(isOpenNewWindow);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdCreateTwoDLineChart failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_setHeatMapSelectedCurveNameIndexs(
        int windowId, QList<int> selectedCurveNameIndexs)
    {
        auto _command = new CmdSetHeatMapSelectedCurveNameIndexs();
        _command->setHeatMapSelectedCurveNameIndexs(windowId, selectedCurveNameIndexs);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSetHeatMapSelectedCurveNameIndexs failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_setHeatMapVariableAxisChanged(int windowId, int variableAxisIndex)
    {
        auto _command = new CmdSetHeatMapVariableAxisChanged();
        _command->setHeatMapVariableAxisChanged(windowId, variableAxisIndex);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("slot_setHeatMapVariableAxisChanged failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_setHeatMapFixedValueChanged(int windowId, QList<int> index)
    {
        auto _command = new CmdSetHeatMapFixedValueChanged();
        _command->setHeatMapFixedValueChanged(windowId, index);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("slot_setHeatMapFixedValueChanged failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_setHeatMapSecondVariableAxisChanged(int windowId, int variableAxisIndex)
    {
        auto _command = new CmdSetHeatMapSecondVariableAxisChanged();
        _command->setHeatMapVariableAxisChanged(windowId, variableAxisIndex);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSetHeatMapSecondVariableAxisChanged failed."));
    }

    void PostCommandPy::slot_setHeatMapComplexPartsChanged(int windowId, bool isAmplitudeChecked, bool isPhaseChecked, bool isRealPartChecked, bool isImaginaryPartChecked)
    {
        auto _command = new CmdSetHeatMapComplexPartsChanged();
        _command->setHeatMapComplexPartsChanged(windowId, isAmplitudeChecked, isPhaseChecked, isRealPartChecked, isImaginaryPartChecked);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("slot_setHeatMapComplexPartsChanged failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_setHeatMapRemoveSelectedGraph(int windowId)
    {
        auto _command = new CmdSetHeatMapRemoveSelectedGraph();
        _command->setHeatMapRemoveSelectedGraph(windowId);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("slot_setHeatMapRemoveSelectedGraph failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_setHeatMapRenameFinished(int windowId, QString name)
    {
        auto _command = new CmdSetHeatMapRenameFinished();
        _command->setHeatMapRenameFinished(windowId, name);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("slot_setHeatMapRenameFinished failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_setHeatMapAddTracer(int windowId, QString name, double x, double y, double value, int tracerStyle, int size, int penR, int penG, int penB, int penA, int interpolating, int curveInfoID, int tracerIndex)
    {
        auto _command = new CmdSetHeatMapAddTracer();
        _command->setHeatMapAddTracer(windowId, name, x, y, value, tracerStyle, size, penR, penG, penB, penA, interpolating, curveInfoID, tracerIndex);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("slot_setHeatMapAddTracer failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_setHeatMapRemoveSelectedTracer(int mainWindowId, QList<int> infoIdList)
    {
        auto _command = new CmdSetHeatMapRemoveSelectedTracer();
        _command->setHeatMapRemoveSelectedTracer(mainWindowId, infoIdList);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSetHeatMapRemoveSelectedTracer failed."));
    }

    void PostCommandPy::slot_setHeatMapRemoveAllTracer(int mainWindowId, QList<int> infoIdList)
    {
        auto _command = new CmdSetHeatMapRemoveAllTracer();
        _command->setHeatMapRemoveAllTracer(mainWindowId, infoIdList);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSetHeatMapRemoveAllTracer failed."));
    }

    void PostCommandPy::slot_setHeatMapExportMarkerData(int mainWindowId, QString fileName)
    {
        auto _command = new CmdSetHeatMapExportMarkerData();
        _command->setHeatMapExportMarkerData(mainWindowId, fileName);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSetHeatMapExportMarkerData failed."));
    }

    void PostCommandPy::slot_setHeatMapChangeTracerProperty(int mainWindowId, QString name, int symbolStyle, int size, int penR, int penG, int penB, int penA, int tracerID)
    {
        auto _command = new CmdSetHeatMapChangeTracerProperty();
        _command->setHeatMapChangeTracerProperty(mainWindowId, name, symbolStyle, size, penR, penG, penB, penA, tracerID);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSetHeatMapChangeTracerProperty failed."));
    }

    void PostCommandPy::slot_setHeatMapCurveNameCheckStateChanged(int windowId, int curveNameIndex, bool checkState)
    {
        auto _command = new CmdSetHeatMapCurveNameCheckStateChanged();
        _command->setCurveNameCheckStateChanged(windowId, curveNameIndex, checkState);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSetHeatMapCurveNameCheckStateChanged failed."));
    }

    void PostCommandPy::slot_setHeatMapDataOprationChanged(int windowId, bool isLoged, bool isNormalized)
    {
        auto _command = new CmdSetHeatMapDataOprationChange();
        _command->setDataOprationChanged(windowId, isLoged, isNormalized);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSetHeatMapDataOprationChange failed."));
    }

    void PostCommandPy::slot_setHeatMapResultValueDataChanged(int windowId, int valueIndex)
    {
        auto _command = new CmdSetHeatMapResultValueDataChanged();
        _command->setHeatMapResultValueDataChanged(windowId, valueIndex);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSetHeatMapResultValueDataChanged failed."));
    }

    void PostCommandPy::slot_saveHeatMapMainSettingData(int windowId, bool scalarBarIsAutoRange, double scalarBarMin,
                                                        double scalarBarMax, QString scalarBarColor, int scalarBarFontSize, bool XAxisAutoTitle, QString XAxisTitle,
                                                        QString XTitleFontColor, int XTitleFontSize, QString XAxisColor, double XAisThickness,
                                                        int XValuePrecision, QString XAxisDigitColor, int XAxisDigitSize, bool XAxisIsAutoRange,
                                                        double XAxisMax, double XAxisMin, bool XIsAutoStepSize, double XCustomStepSize, bool YAxisAutoTitle, QString YAxisTitle,
                                                        QString YTitleFontColor, int YTitleFontSize, QString YAxisColor, double YAisThickness,
                                                        int YValuePrecision, QString YAxisDigitColor, int YAxisDigitSize, bool YAxisIsAutoRange,
                                                        double YAxisMax, double YAxisMin, bool YIsAutoStepSize, double YCustomStepSize,
                                                        bool gridIsMainGridLineDisplay, QString gridMainGridLineColor, int gridMainGridLineStyle,
                                                        double gridMainGridLineThickness, bool gridIsSecondaryGridLineDisplay, QString gridSecondaryGridLineColor,
                                                        int gridSecondaryGridLineStyle, double gridSecondaryGridLineThickness,
                                                        QString windowTitleName, QString windowTitleFontColor, int windowTitleFontSize)
    {
        auto _command = new CmdSaveHeatMapMainSettingData();
        _command->setHeatMapMainSettingData(windowId, scalarBarIsAutoRange, scalarBarMin,
                                            scalarBarMax, scalarBarColor, scalarBarFontSize, XAxisAutoTitle, XAxisTitle,
                                            XTitleFontColor, XTitleFontSize, XAxisColor, XAisThickness,
                                            XValuePrecision, XAxisDigitColor, XAxisDigitSize, XAxisIsAutoRange,
                                            XAxisMax, XAxisMin, XIsAutoStepSize, XCustomStepSize, YAxisAutoTitle, YAxisTitle,
                                            YTitleFontColor, YTitleFontSize, YAxisColor, YAisThickness,
                                            YValuePrecision, YAxisDigitColor, YAxisDigitSize, YAxisIsAutoRange,
                                            YAxisMax, YAxisMin, YIsAutoStepSize, YCustomStepSize,
                                            gridIsMainGridLineDisplay, gridMainGridLineColor, gridMainGridLineStyle,
                                            gridMainGridLineThickness, gridIsSecondaryGridLineDisplay, gridSecondaryGridLineColor,
                                            gridSecondaryGridLineStyle, gridSecondaryGridLineThickness,
                                            windowTitleName, windowTitleFontColor, windowTitleFontSize);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSaveHeatMapMainSettingData failed."));
    }

    void PostCommandPy::slot_lineChartSidebarVariableAxisChanged(int mainWindowId, QList<int> allSelectedItem, int reuslt, QString sVariableAxistCurrentText)
    {
        auto _command = new CmdLineChartSidebarVariableAxisChanged();
        _command->setLineChartSidebarVariableAxisChanged(mainWindowId, allSelectedItem, reuslt, sVariableAxistCurrentText);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdLineChartSidebarVariableAxisChanged failed."));
    }

    void PostCommandPy::slot_lineChartSidebarCurveNameClicked(int mainWindowId, QList<int> allSelectedItemIndexList)
    {
        auto _command = new CmdLineChartSidebarCurveNameClicked();
        _command->setLineChartSidebarCurveNameClicked(mainWindowId, allSelectedItemIndexList);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdLineChartSidebarCurveNameClicked failed."));
    }

    void PostCommandPy::slot_lineChartSidebarCurveNameCheckStateChanged(int mainWindowId, int index, int checkStatus)
    {
        auto _command = new CmdLineChartSidebarCurveNameCheckStateChanged();
        _command->setLineChartSidebarCurveNameCheckStateChanged(mainWindowId, index, checkStatus);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdLineChartSidebarCurveNameCheckStateChanged failed."));
    }

    void PostCommandPy::slot_lineChartSidebarDataOperationChanged(int mainWindowId, bool isNormChecked, bool isDBChecked, bool isMathOperationChecked)
    {
        auto _command = new CmdLineChartSidebarDataOperationChanged();
        _command->setLineChartSidebarDataOperationChanged(mainWindowId, isNormChecked, isDBChecked, isMathOperationChecked);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdLineChartSidebarDataOperationChanged failed."));
    }

    void PostCommandPy::slot_lineChartSidebarFixedValueChanged(int mainWindowId, QList<int> allIndexList)
    {
        auto _command = new CmdLineChartSidebarFixedValueChanged();
        _command->setLineChartSidebarFixedValueChanged(mainWindowId, allIndexList);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdLineChartSidebarFixedValueChanged failed."));
    }

    void PostCommandPy::slot_lineChartSidebarValueDataChanged(int mainWindowId, int currentIndex)
    {
        auto _command = new CmdLineChartSidebarValueDataChanged();
        _command->setLineChartSidebarValueDataChanged(mainWindowId, currentIndex);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdLineChartSidebarValueDataChanged failed."));
    }

    void PostCommandPy::slot_saveLineChartMainSettingData(int mainWindowId, int index, bool axiDisIsAutoName, QString axiDisTitleText, QString axiDisTitleFontColorStr, int axiDisTitleFontSize, QString axiDisAxisColorStr, int axiDisAxisThickness, double axiDisValuePrecision, QString axiDisAxisDigitColorStr, int axiDisAxisDigitSize,
                                                          bool axiRangIsAutoRange, double axiRangMaxValue, double axiRangMinValue, bool axiRangIsAutoStepSize, double axiRangCustomStepSize,
                                                          bool yAxiDisIsAutoName, QString yAxiDisTitleText, QString yAxiDisTitleFontColorStr, int yAxiDisTitleFontSize, QString yAxiDisAxisColorStr, int yAxiDisAxisThickness, double yAxiDisValuePrecision, QString yAxiDisAxisDigitColorStr, int yAxiDisAxisDigitSize,
                                                          bool yAxiRangIsAutoRange, double yAxiRangMaxValue, double yAxiRangMinValue, bool yAxiRangIsAutoStepSize, double yAxiRangCustomStepSize,
                                                          bool gridIsMainGridLineDisplay, QString gridMainGridLineColorStr, int gridMainGridLineStyle, double gridMainGridLineThickness, bool gridIsSecondaryGridLineDisplay, QString gridSecondaryGridLineColorStr, int gridSecondaryGridLineStyle, double gridSecondaryGridLineThickness,
                                                          QString titleName, QString titleFontColorStr, int titleFontSize,
                                                          QString legendFontColorStr, int legendFontSize, QString legendLineColorStr, int legendLineThickness,
                                                          QString resultDataName, QString dataLineColorStr, int dataLineStyle, double dataLineThickness, bool isDisplaySymbol, int symbolStyle, double symbolSize, QString symbolColorStr)
    {
        auto _command = new CmdSaveLineChartMainSettingData();
        _command->setLineChartMainSettingData(mainWindowId, index,
                                              axiDisIsAutoName, axiDisTitleText, axiDisTitleFontColorStr, axiDisTitleFontSize, axiDisAxisColorStr, axiDisAxisThickness, axiDisValuePrecision, axiDisAxisDigitColorStr, axiDisAxisDigitSize,
                                              axiRangIsAutoRange, axiRangMaxValue, axiRangMinValue, axiRangIsAutoStepSize, axiRangCustomStepSize,
                                              yAxiDisIsAutoName, yAxiDisTitleText, yAxiDisTitleFontColorStr, yAxiDisTitleFontSize, yAxiDisAxisColorStr, yAxiDisAxisThickness, yAxiDisValuePrecision, yAxiDisAxisDigitColorStr, yAxiDisAxisDigitSize,
                                              yAxiRangIsAutoRange, yAxiRangMaxValue, yAxiRangMinValue, yAxiRangIsAutoStepSize, yAxiRangCustomStepSize,
                                              gridIsMainGridLineDisplay, gridMainGridLineColorStr, gridMainGridLineStyle, gridMainGridLineThickness, gridIsSecondaryGridLineDisplay, gridSecondaryGridLineColorStr, gridSecondaryGridLineStyle, gridSecondaryGridLineThickness,
                                              titleName, titleFontColorStr, titleFontSize,
                                              legendFontColorStr, legendFontSize, legendLineColorStr, legendLineThickness,
                                              resultDataName, dataLineColorStr, dataLineStyle, dataLineThickness, isDisplaySymbol, symbolStyle, symbolSize, symbolColorStr);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdLineChartSidebarDataOperationChanged failed."));
    }

    void PostCommandPy::slot_polarCoordinateGraphSidebarVariableAxisChanged(int mainWindowId, QList<int> allSelectedItem, int reuslt, QString sVariableAxistCurrentText)
    {
        auto _command = new CmdPolarCoordinateGraphSidebarVariableAxisChanged();
        _command->setPolarCoordinateGraphSidebarVariableAxisChanged(mainWindowId, allSelectedItem, reuslt, sVariableAxistCurrentText);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdPolarCoordinateGraphSidebarVariableAxisChanged failed."));
    }

    void PostCommandPy::slot_polarCoordinateGraphSidebarAllVariableAxisChanged(int mainWindowId, QString sVariableAxistCurrentText)
    {
        auto _command = new CmdPolarCoordinateGraphSidebarAllVariableAxisChanged();
        _command->setPolarCoordinateGraphSidebarAllVariableAxisChanged(mainWindowId, sVariableAxistCurrentText);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdPolarCoordinateGraphSidebarAllVariableAxisChanged failed."));
    }

    void PostCommandPy::slot_polarCoordinateGraphSidebarCurveNameClicked(int mainWindowId, QList<int> allSelectedItemIndexList)
    {
        auto _command = new CmdPolarCoordinateGraphSidebarCurveNameClicked();
        _command->setPolarCoordinateGraphSidebarCurveNameClicked(mainWindowId, allSelectedItemIndexList);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdPolarCoordinateGraphSidebarCurveNameClicked failed."));
    }

    void PostCommandPy::slot_polarCoordinateGraphSidebarCurveNameCheckStateChanged(int mainWindowId, int index, int checkStatus)
    {
        auto _command = new CmdPolarCoordinateGraphSidebarCurveNameCheckStateChanged();
        _command->setPolarCoordinateGraphSidebarCurveNameCheckStateChanged(mainWindowId, index, checkStatus);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdPolarCoordinateGraphSidebarCurveNameCheckStateChanged failed."));
    }

    void PostCommandPy::slot_polarCoordinateGraphSidebarDataOperationChanged(int mainWindowId, bool isNormChecked, bool isDBChecked)
    {
        auto _command = new CmdPolarCoordinateGraphSidebarDataOperationChanged();
        _command->setPolarCoordinateGraphSidebarDataOperationChanged(mainWindowId, isNormChecked, isDBChecked);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdPolarCoordinateGraphSidebarDataOperationChanged failed."));
    }

    void PostCommandPy::slot_polarCoordinateGraphSidebarValueDataChanged(int mainWindowId, int currentIndex)
    {
        auto _command = new CmdPolarCoordinateGraphSidebarValueDataChanged();
        _command->setPolarCoordinateGraphSidebarValueDataChanged(mainWindowId, currentIndex);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdPolarCoordinateGraphSidebarDataOperationChanged failed."));
    }

    void PostCommandPy::slot_polarCoordinateGraphSidebarDeleteAllGraph(int mainWindowId)
    {
        auto _command = new CmdPolarCoordinateGraphSidebarDeleteAllGraph();
        _command->setPolarCoordinateGraphSidebarDeleteAllGraph(mainWindowId);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdPolarCoordinateGraphSidebarDeleteAllGraph failed."));
    }

    void PostCommandPy::slot_polarCoordinateGraphSidebarCopySelectedGraph(int mainWindowId)
    {
        auto _command = new CmdPolarCoordinateGraphSidebarCopySelectedGraph();
        _command->setPolarCoordinateGraphSidebarCopySelectedGraph(mainWindowId);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdPolarCoordinateGraphSidebarCopySelectedGraph failed."));
    }

    void PostCommandPy::slot_polarCoordinateGraphAddTracer(int mainWindowId, QString name, double angle, int tracerStyle, int size, int penR, int penG, int penB, int penA,
        int brushR, int brushG, int brushB, int brushA, int interpolating, int curveInfoID, int tracerIndex)
    {
        auto _command = new CmdPolarCoordinateGraphAddTracer();
        _command->setPolarCoordinateGraphAddTracer(mainWindowId, name, angle, tracerStyle, size,
            penR, penG, penB, penA, brushR, brushG, brushB, brushA, interpolating, curveInfoID, tracerIndex);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdPolarCoordinateGraphAddTracer failed."));
    }

    void PostCommandPy::slot_polarCoordinateGraphRemoveSelectedTracer(int mainWindowId, QList<int> infoIdList, int curveInfoID)
    {
        auto _command = new CmdPolarCoordinateGraphRemoveSelectedTracer();
        _command->setPolarCoordinateGraphRemoveSelectedTracer(mainWindowId, infoIdList, curveInfoID);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdPolarCoordinateGraphRemoveSelectedTracer failed."));
    }

    void PostCommandPy::slot_polarCoordinateGraphRemoveAllTracer(int mainWindowId, QList<int> infoIdList)
    {
        auto _command = new CmdPolarCoordinateGraphRemoveAllTracer();
        _command->setPolarCoordinateGraphRemoveAllTracer(mainWindowId, infoIdList);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdPolarCoordinateGraphRemoveAllTracer failed."));
    }

    void PostCommandPy::slot_polarCoordinateGraphExportMarkerData(int mainWindowId, QString fileName)
    {
        auto _command = new CmdPolarCoordinateGraphExportMarkerData();
        _command->setPolarCoordinateGraphExportMarkerData(mainWindowId, fileName);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdPolarCoordinateGraphExportMarkerData failed."));
    }

    void PostCommandPy::slot_polarCoordinateGraphChangeTracerProperty(int mainWindowId, QString name, double x, int symbolStyle, int size, int penR, int penG, int penB, int penA, int tracerID)
    {
        auto _command = new CmdPolarCoordinateGraphChangeTracerProperty();
        _command->setPolarCoordinateGraphChangeTracerProperty(mainWindowId, name, x, symbolStyle, size, penR, penG, penB, penA, tracerID);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdPolarCoordinateGraphChangeTracerProperty failed."));
    }

    void PostCommandPy::slot_polarCoordinateGraphSidebarRenameSelectedGraph(int mainWindowId, QString name)
    {
        auto _command = new CmdPolarCoordinateGraphSidebarRenameSelectedGraph();
        _command->setPolarCoordinateGraphSidebarRenameSelectedGraph(mainWindowId, name);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdPolarCoordinateGraphSidebarRenameSelectedGraph failed."));
    }

    void PostCommandPy::slot_polarCoordinateGraphSidebarComplexPartsChanged(int mainWindowId, bool isAmplitudeChecked, bool isPhaseChecked, bool isRealPartChecked, bool isImaginaryPartChecked)
    {
        auto _command = new CmdPolarCoordinateGraphSidebarComplexPartsChanged();
        _command->setPolarCoordinateGraphSidebarComplexPartsChanged(mainWindowId, isAmplitudeChecked, isPhaseChecked, isRealPartChecked, isImaginaryPartChecked);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdPolarCoordinateGraphSidebarComplexPartsChanged failed."));
    }

    void PostCommandPy::slot_polarCoordinateGraphSidebarFixedValueChanged(int mainWindowId, QList<int> indexList)
    {
        auto _command = new CmdPolarCoordinateGraphSidebarFixedValueChanged();
        _command->setPolarCoordinateGraphSidebarFixedValueChanged(mainWindowId, indexList);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdPolarCoordinateGraphSidebarFixedValueChanged failed."));
    }

    void PostCommandPy::slot_polarCoordinateGraphSidebarRemoveSelectedGraph(int mainWindowId, QList<int> indexList)
    {
        auto _command = new CmdPolarCoordinateGraphSidebarRemoveSelectedGraph();
        _command->setPolarCoordinateGraphSidebarRemoveSelectedGraph(mainWindowId, indexList);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdPolarCoordinateGraphSidebarRemoveSelectedGraph failed."));
    }

    void PostCommandPy::slot_savePolarCoordinateGraphMainSettingData(int mainWindowId, int index, QString(angDisAxisColor), int angDisAxisThickness, double angDisValuePrecision, QString(angDisAxisDigitColor), int angDisAxisDigitSize,
                                                                     bool angRangIsAutoStepSize, double angRangCustomStepSize,
                                                                     QString(radDisAxisColor), int radDisAxisThickness, double radDisValuePrecision, QString(radDisAxisDigitColor), int radDisAxisDigitSize,
                                                                     bool radRangIsAutoRange, double radRangMaxValue, double radRangMinValue, bool radRangIsAutoStepSize, double radRangCustomStepSize,
                                                                     bool gridIsMainGridLineDisplay, QString(gridMainGridLineColor), int gridMainGridLineStyle, double gridMainGridLineThickness,
                                                                     QString(titleName), QString(titleFontColor), int titleFontSize,
                                                                     QString(legendFontColor), int legendFontSize, QString(legendLineColor), int legendLineThickness,
                                                                     QString(dataProResultDataName), QString(dataProDataLineColor), int dataProDataLineStyle, double dataProDataLineThickness, bool dataProIsDisplaySymbol, int dataProSymbolStyle, double dataProSymbolSize, QString(dataProSymbolColor))
    {
        auto _command = new CmdSavePolarCoordinateGraphMainSettingData();
        _command->setPolarCoordinateGraphMainSettingData(mainWindowId, index,
                                                         angDisAxisColor, angDisAxisThickness, angDisValuePrecision, angDisAxisDigitColor, angDisAxisDigitSize,
                                                         angRangIsAutoStepSize, angRangCustomStepSize,
                                                         radDisAxisColor, radDisAxisThickness, radDisValuePrecision, radDisAxisDigitColor, radDisAxisDigitSize,
                                                         radRangIsAutoRange, radRangMaxValue, radRangMinValue, radRangIsAutoStepSize, radRangCustomStepSize,
                                                         gridIsMainGridLineDisplay, gridMainGridLineColor, gridMainGridLineStyle, gridMainGridLineThickness,
                                                         titleName, titleFontColor, titleFontSize,
                                                         legendFontColor, legendFontSize, legendLineColor, legendLineThickness,
                                                         dataProResultDataName, dataProDataLineColor, dataProDataLineStyle, dataProDataLineThickness, dataProIsDisplaySymbol, dataProSymbolStyle, dataProSymbolSize, dataProSymbolColor);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdPolarCoordinateGraphSidebarDataOperationChanged failed."));
    }

    void PostCommandPy::slot_openProject()
    {
        auto _command = new CmdOpenProject();
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }
    
    void PostCommandPy::slot_importProjectData(QString data)
    {
        auto _command = new CmdImportProjectData();
        _command->setData(data);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Stop);
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_createThreeDSurfacePlot(int graphType, int variableIndex, int frequencyIndex, int readerIndex, QString filePath, QString name, QString geometryFileName, bool isOpenNewWindow)
    {
        auto _command = new CmdCreateThreeDSurfacePlot();
        _command->setGraphType(graphType);
        _command->setVariableIndex(variableIndex);
        _command->setFrequencyIndex(frequencyIndex);
        _command->setReaderIndex(readerIndex);
        _command->setFilePath(filePath);
        _command->setName(name);
        _command->setGeometryFileName(geometryFileName);
        _command->setIsOpenNewWindow(isOpenNewWindow);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdCreateThreeDSurfacePlot failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_threeDSurfacePlotSidebarCurveNameClicked(int windowId, QList<int> selectedIndexes)
    {
        auto _command = new CmdThreeDSurfacePlotSidebarCurveNameClicked();
        _command->setThreeDSurfacePlotSidebarCurveNameClicked(windowId, selectedIndexes);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdThreeDSurfacePlotSidebarCurveNameClicked failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_threeDSurfacePlotSidebarFrequencyChanged(int windowId, int frequencyId)
    {
        auto _command = new CmdThreeDSurfacePlotSidebarFrequencyChanged();
        _command->setThreeDSurfacePlotSidebarFrequencyChanged(windowId, frequencyId);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdThreeDSurfacePlotSidebarFrequencyChanged failed."));
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_threeDSurfacePlotSidebarResultDataChanged(int windowId, int resultDataIndex)
    {
        auto _command = new CmdThreeDSurfacePlotSidebarResultDataChanged();
        _command->setThreeDSurfacePlotSidebarResultDataChanged(windowId, resultDataIndex);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdThreeDSurfacePlotSidebarResultDataChanged failed."));
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_threeDSurfacePlotSidebarDataOprationChanged(int windowId, bool isLoged, bool isNormalized)
    {
        auto _command = new CmdThreeDSurfacePlotSidebarDataOprationChanged();
        _command->setThreeDSurfacePlotSidebarDataOprationChanged(windowId, isLoged, isNormalized);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdThreeDSurfacePlotSidebarDataOprationChanged failed."));
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_threeDSurfacePlotSidebarCurveNameItemCheckStateChanged(int windowId, int itemIndex, bool checkState)
    {
        auto _command = new CmdThreeDSurfacePlotSidebarCurveNameItemCheckStateChanged();
        _command->setThreeDSurfacePlotSidebarCurveNameItemCheckStateChanged(windowId, itemIndex, checkState);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdThreeDSurfacePlotSidebarCurveNameItemCheckStateChanged failed."));
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_saveThreeDSurfacePlotMainSettingData(int windowId, int settignDataId, bool scalarBarIsAutoRange, double scalarBarMin,
                                                                  double scalarBarMax, bool scalarBarIsShowTitle, QString scalarBarTitle, QString scalarBarFontColor, int scalarBarFontSize,
                                                                  int geometryTransparency, QString resultGraphName, int resultGraphModelTransparency, double resultGraphScale, bool cubeAxesIsVisible)
    {
        auto _command = new CmdSaveThreeDSurfacePlotMainSettingData();
        _command->saveThreeDSurfacePlotMainSettingData(windowId, settignDataId, scalarBarIsAutoRange,
                                                       scalarBarMin, scalarBarMax, scalarBarIsShowTitle, scalarBarTitle, scalarBarFontColor, scalarBarFontSize,
                                                       geometryTransparency, resultGraphName, resultGraphModelTransparency, resultGraphScale, cubeAxesIsVisible);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSaveThreeDSurfacePlotMainSettingData failed."));
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_saveThreeDSurfacePlotMoveResultDataSetting(int windowId, int infomationId, double translationX, double translationY, double translationZ,
                                                                        double rotationTheta, double rotationPhi)
    {
        auto _command = new CmdSaveThreeDSurfacePlotMoveResultDataSetting();
        _command->saveThreeDSurfacePlotMoveResultDataSetting(windowId, infomationId, translationX, translationY, translationZ,
                                                             rotationTheta, rotationPhi);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSaveThreeDSurfacePlotMoveResultDataSetting failed."));
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_delete3DSurfacePlots(int windowId, QString selectedIndexs)
    {
        auto _command = new CmdDelete3DSurfacePlots();
        _command->setArgs(windowId, selectedIndexs);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("PostCommandPy::slot_delete3DSurfacePlots failed."));
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_threeDSurfaceCurveNameItemRename(int windowId, int itemIndex, QString newName)
    {
        auto _command = new CmdThreeDSurfaceCurveNameItemRename();
        _command->setArgs(windowId, itemIndex, newName);
        bool _success = false;

        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("PostCommandPy::slot_threeDSurfaceCurveNameItemRename failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_threeDSurfaceCurveDataFileterRadioButtonClicked(int windowId, int index)
    {
        auto _command = new CmdThreeDSurfaceCurveDataFileterRadioButtonClicked();
        _command->setArgs(windowId, index);
        bool _success = false;

        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("PostCommandPy::slot_threeDSurfaceCurveDataFileterRadioButtonClicked failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }


    void PostCommand::PostCommandPy::slot_createThreeDCloudMap(bool useNewWindow, int graphType, int variableIndex, int readerIndex, QString filePath, QString name, QString geometryFileName, int resultDataIndex)
    {
        auto _command = new CmdCreateThreeDCloudMap();
        _command->setUseNewWindow(useNewWindow);
        _command->setGraphType(graphType);
        _command->setVariableIndex(variableIndex);
        _command->setReaderIndex(readerIndex);
        _command->setFilePath(filePath);
        _command->setName(name);
        _command->setGeometryFileName(geometryFileName);
        _command->setResultDataIndex(resultDataIndex);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdCreateThreeDCloudMap failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_threeDCloudMapSidebarCurveNameClicked(int windowId, QList<int> selectedIndexes)
    {
        auto _command = new CmdThreeDCloudMapSidebarCurveNameClicked();
        _command->setThreeDCloudMapSidebarCurveNameClicked(windowId, selectedIndexes);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdThreeDCloudMapSidebarCurveNameClicked failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_threeDCloudMapSidebarUpdateFixedParameter(int windowId, int index)
    {
        auto _command = new CmdThreeDCloudMapSidebarUpdateFixedParameter();
        _command->setThreeDCloudMapSidebarFixedParameter(windowId, index);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdThreeDCloudMapSidebarUpdateFixedParameter failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_threeDCloudMapSidebarUpdateOriginalDataSource(int windowId, int index, int showType, int fixedValueIndex, bool isLog, bool isNormalize)
    {
        auto _command = new CmdThreeDCloudMapSidebarUpdateOriginalDataSource();
        _command->setThreeDCloudMapSidebarOriginalDataSource(windowId, index, showType, fixedValueIndex, isLog, isNormalize);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdThreeDCloudMapSidebarUpdateOriginalDataSource failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_threeDCloudMapSidebarResultDataChanged(int windowId, int index)
    {
        auto _command = new CmdThreeDCloudMapSidebarResultDataChanged();
        _command->setThreeDCloudMapSidebarResultDataChanged(windowId, index);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdThreeDCloudMapSidebarResultDataChanged failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_threeDCloudMapSidebarNameItemRename(int windowId, int itemIndex, QString newName)
    {
        auto _command = new CmdThreeDCloudMapSidebarNameItemRename();
        _command->setArgs(windowId, itemIndex, newName);
        bool _success = false;

        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdThreeDCloudMapSidebarNameItemRename failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_threeDCloudMapSidebarDelete3DCloudMap(int windowId, QString selectedIndexs)
    {
        auto _command = new CmdThreeDCloudMapSidebarDelete3DCloudMap();
        _command->setArgs(windowId, selectedIndexs);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdThreeDCloudMapSidebarDelete3DCloudMap failed."));
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_threeDCloudMapSidebarDataOprationChanged(int windowId, bool isLoged, bool isNormalized)
    {
        auto _command = new CmdThreeDCloudMapSidebarDataOprationChanged();
        _command->setThreeDCloudMapSidebarDataOprationChanged(windowId, isLoged, isNormalized);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdThreeDCloudMapSidebarDataOprationChanged failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_threeDCloudMapSidebarItemCheckStateChanged(int windowId, int itemIndex, bool visible)
    {
        auto _command = new CmdThreeDCloudMapSidebarItemCheckStateChanged();
        _command->setThreeDCloudMapSidebarItemCheckStateChanged(windowId, itemIndex, visible);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdThreeDCloudMapSidebarItemCheckStateChanged failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_saveThreeDCloudMapMainSettingData(int windowId, int type, int settingDataId, bool scalarBarIsAutoRange,
                                                               double scalarBarMin, double scalarBarMax, bool scalarBarIsShowTitle,
                                                               QString scalarBarTitle, QString scalarBarFontColor, int scalarBarFontSize,
                                                               int geometryTransparency, QString resultGraphName, int resultGraphModelTransparency, bool cubeAxesIsVisible)
    {
        auto _command = new CmdSaveThreeDCloudMapMainSettingData();
        _command->saveThreeDCloudMapMainSettingData(windowId, type, settingDataId, scalarBarIsAutoRange,
                                                    scalarBarMin, scalarBarMax, scalarBarIsShowTitle, scalarBarTitle, scalarBarFontColor, scalarBarFontSize,
                                                    geometryTransparency, resultGraphName, resultGraphModelTransparency, cubeAxesIsVisible);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSaveThreeDCloudMapMainSettingData failed."));
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_createSurfaceElectricFieldGraph(int graphType, int currentIndex, int readerIndex, QString sReaderType, QString sFilePath, QString sName, QString geometryFileName, bool isOpenNewWindow)
    {
        auto _command = new CmdCreateSurfaceElectricFieldGraph();
        _command->setCurrentIndex(currentIndex);
        _command->setReaderIndex(readerIndex);
        _command->setReaderType(sReaderType);
        _command->setGraphType(graphType);
        _command->setFilePath(sFilePath);
        _command->setName(sName);
        _command->setGeometryFileName(geometryFileName);
        _command->setIsOpenNewWindow(isOpenNewWindow);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdCreateSurfaceElectricFieldGraph failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_surfaceElectricFieldMapSidebarCurveNameClicked(int windowId, QList<int> selectedIndexes)
    {
        auto _command = new CmdSurfaceElectricFieldMapSidebarCurveNameClicked();
        _command->setSurfaceElectricFieldMapSidebarCurveNameClicked(windowId, selectedIndexes);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSurfaceElectricFieldMapSidebarCurveNameClicked failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_surfaceElectricFieldMapSidebarResultDataChanged(int windowId, int index)
    {
        auto _command = new CmdSurfaceElectricFieldMapSidebarResultDataChanged();
        _command->setSurfaceElectricFieldMapSidebarResultDataChanged(windowId, index);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSurfaceElectricFieldMapSidebarResultDataChanged failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_surfaceElectricFieldMapSidebarUpdateProcessData(int windowId, bool isLog, bool isNormalize)
    {
        auto _command = new CmdSurfaceElectricFieldMapSidebarUpdateProcessData();
        _command->setSurfaceElectricFieldMapSidebarUpdateProcessData(windowId, isLog, isNormalize);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSurfaceElectricFieldMapSidebarUpdateProcessData failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_surfaceElectricFieldMapSidebarNameItemRename(int windowId, int itemIndex, QString newName)
    {
        auto _command = new CmdSurfaceElectricFieldMapSidebarNameItemRename();
        _command->setArgs(windowId, itemIndex, newName);
        bool _success = false;

        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSurfaceElectricFieldMapSidebarNameItemRename failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_surfaceElectricFieldMapSidebarDeleteSurfaceElectricFieldMap(int windowId, QString selectedIndexs)
    {
        auto _command = new CmdSurfaceElectricFieldMapSidebarDeleteSurfaceElectricFieldMap();
        _command->setArgs(windowId, selectedIndexs);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSurfaceElectricFieldMapSidebarDeleteSurfaceElectricFieldMap failed."));
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_surfaceElectricFieldMapSidebarItemCheckStateChanged(int windowId, int itemIndex, bool visible)
    {
        auto _command = new CmdSurfaceElectricFieldMapSidebarItemCheckStateChanged();
        _command->setSurfaceElectricFieldMapSidebarItemCheckStateChanged(windowId, itemIndex, visible);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSurfaceElectricFieldMapSidebarItemCheckStateChanged failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_saveSurfaceElectricFieldMapMainSettingData(int windowId, int type, int settingDataId, bool scalarBarIsAutoRange,
                                                                        double scalarBarMin, double scalarBarMax, bool scalarBarIsShowTitle,
                                                                        QString scalarBarTitle, QString scalarBarFontColor, int scalarBarFontSize,
                                                                        int geometryTransparency, QString resultGraphName, int resultGraphModelTransparency, bool cubeAxesIsVisible)
    {
        auto _command = new CmdSaveSurfaceElectricFieldMapMainSettingData();
        _command->saveSurfaceElectricFieldMapMainSettingData(windowId, type, settingDataId, scalarBarIsAutoRange,
                                                             scalarBarMin, scalarBarMax, scalarBarIsShowTitle, scalarBarTitle, scalarBarFontColor, scalarBarFontSize,
                                                             geometryTransparency, resultGraphName, resultGraphModelTransparency, cubeAxesIsVisible);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSaveSurfaceElectricFieldMapMainSettingData failed."));
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_savePostMarkerAddSettingData(int windowUniversalID, int infomationGraph3DBasicalId, int type,
                                                          int fieldIndex, QString fieldName, int pickedId, QString pickedValue)
    {
        auto _command = new CmdSavePostMarkerAddSettingData();
        _command->savePostMarkerAddSettingData(windowUniversalID, infomationGraph3DBasicalId, type, fieldIndex,
                                               fieldName, pickedId, pickedValue);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSavePostMarkerAddSettingData failed."));
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_savePostMarkerRemoveChosenSettingData(int windowUniversalID, QString removeChosenId)
    {
        auto _command = new CmdSavePostMarkerRemoveChosenSettingData();
        _command->savePostMarkerRemoveChosenSettingData(windowUniversalID, removeChosenId);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSavePostMarkerRemoveChosenSettingData failed."));
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_savePostMarkerRemoveAllSettingData(int windowUniversalID)
    {
        auto _command = new CmdSavePostMarkerRemoveAllSettingData();
        _command->savePostMarkerRemoveAllSettingData(windowUniversalID);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSavePostMarkerRemoveAllSettingData failed."));
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_savePostMarkerExportTableData(int windowUniversalID, QString fileName)
    {
        auto _command = new CmdSavePostMarkerExportTableData();
        _command->savePostMarkerExportTableData(windowUniversalID, fileName);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSavePostMarkerExportTableData failed."));
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_saveModelDisplaySettingData(int windowUniversalID, bool toolButtonActiveClipperIsChecked, bool toolButtonModelDisplayIsChecked, bool hasAnyGeometrySuccess)
    {
        auto _command = new CmdSaveModelDisplaySettingData();
        _command->saveModelDisplaySettingData(windowUniversalID, toolButtonActiveClipperIsChecked, toolButtonModelDisplayIsChecked, hasAnyGeometrySuccess);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSaveModelDisplaySettingData failed."));
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_saveActiveClipperSettingData(int windowUniversalID, bool toolButtonActiveClipperIsChecked, bool toolButtonModelDisplayIsChecked, bool hasAnyGeometrySuccess, QString direction, double clipperValue)
    {
        auto _command = new CmdSaveActiveClipperSettingData();
        _command->saveActiveClipperSettingData(windowUniversalID, toolButtonActiveClipperIsChecked, toolButtonModelDisplayIsChecked, hasAnyGeometrySuccess, direction, clipperValue);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSaveActiveClipperSettingData failed."));
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_createTableWidget(int readerIndex)
    {
        auto _command = new CmdCreateTableWidget();
        _command->setReaderIndex(readerIndex);

        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdCreateTableWidget failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_hideOrShowTableColumn(int windowId, QString selectedIndex)
    {
        auto _command = new CmdTbHideOrShowTableColumn();
        _command->setWindowId(windowId);
        _command->setSelectedIndex(selectedIndex);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdTbHideOrShowTableColumn failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_changeTbColumnName(int windowId, int index, QString newName)
    {
        auto _command = new CmdTbChangeColumnName();
        _command->setWindowId(windowId);
        _command->setNewName(newName);
        _command->setIndex(index);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdTbChangeColumnName failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_flushTbBySelectedRow(int windowId, QString parms)
    {
        auto _command = new CmdTbFlushTbBySelectedRow();
        _command->setWindowId(windowId);
        _command->setParms(parms);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdTbFlushTbBySelectedRow failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_exportTbData(int windowId, QString filePath, QString delimiter, int onlyVisible)
    {
        auto _command = new CmdTbExportData();
        _command->setWindowId(windowId);
        _command->setFilePath(filePath);
        _command->setDelimiter(delimiter);
        _command->setOnlyVisible(onlyVisible);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdTbExportData failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_highlightSelectedTbColumns(int windowId, QString parms)
    {
        auto _command = new CmdTbhighlightSelectedColumns();
        _command->setWindowId(windowId);
        _command->setParms(parms);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdTbhighlightSelectedColumns failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_doPrjFileWrite(QString fileName)
    {
        auto _command = new CmdAppPrjFileWrite();
        _command->setFileName(fileName);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdAppPrjFileWrite failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_doPrjFileRead(QString fileName)
    {
        auto _command = new CmdAppPrjFileRead();
        _command->setFileName(fileName);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdAppPrjFileRead failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_doPrjCloseTree(int index)
    {
        auto _command = new CmdDoPrjCloseTree();
        _command->setIndex(index);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdDoPrjCloseTree failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_doPrjTreeCopyDir(int index)
    {
        auto _command = new CmdDoPrjTreeCopyDir();
        _command->setIndex(index);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdDoPrjTreeCopyDir failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_doPrjTreePasteDir(int srcId, int destId)
    {
        auto _command = new CmdDoPrjTreePasteDir();
        _command->setSrcId(srcId);
        _command->setDestId(destId);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdDoPrjTreePasteDir failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_doPrjTreeCopyData(int index)
    {
        auto _command = new CmdDoPrjTreeCopyData();
        _command->setIndex(index);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdDoPrjTreeCopyData failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_doPrjTreePasteData(int srcId, int destId)
    {
        auto _command = new CmdDoPrjTreePasteData();
        _command->setSrcId(srcId);
        _command->setDestId(destId);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdDoPrjTreePasteDir failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_doPrjTreeExpandDir(int index)
    {
        auto _command = new CmdDoPrjTreeExpandDir();
        _command->setIndex(index);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdDoPrjTreeExpandDir failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_doPrjTreeCollapseDir(int index)
    {
        auto _command = new CmdDoPrjTreeCollapseDir();
        _command->setIndex(index);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdDoPrjTreeExpandDir failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_closeCenterTableBar(int index)
    {
        auto _command = new CmdCloseCenterTableBar();
        _command->setIndex(index);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdCloseCenterTableBar failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_changeCurrentTabBar(int index)
    {
        auto _command = new CmdChangeCurrentTabBar();
        _command->setIndex(index);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdChangeCurrentTabBar failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_submitEvaluation(int windowId, int evaluationType, QString parms)
    {
        auto _command = new CmdSubmitEvaluation();
        _command->setWindowId(windowId);
        _command->setEvaluationType(evaluationType);
        _command->setParms(parms);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
            putErrorMsg(QObject::tr("CmdSubmitEvaluation failed."));

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    

    void PostCommandPy::slot_exportPstData(QString filePath)
    {
        auto _command = new CmdExportPstData();
        _command->setFilePath(filePath);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);

        if (!_success)
        {
            putErrorMsg(QObject::tr("PostCommandPy::slot_exportPstData failed."));
        }
        else
        {
            putErrorMsg(QObject::tr("PostCommandPy::slot_exportPstData success."));
        }
        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

    void PostCommandPy::slot_sentWaveButterANdFFTVResult(int windowId, QString resultList)
    {
        auto _command = new CmdWaveButterANdFFT();
        _command->setResult(windowId, resultList);
        bool _success = false;
        emit CommandManagerInstance->slot_execCommand(_command, &_success);
        if (!_success)
        {
            putErrorMsg(QObject::tr("CmdWaveButterANdFFT failed."));
        }

        emit IBaseSignalInstance->signal_execScriptManager(BaseModule::EScriptManager::Unlock);
    }

} // namespace PostCommand
